package net.molchat.android.scrn;


import net.molchat.android.cont.Cont;
import net.molchat.android.cont.ContGraph;
import net.molchat.android.core.Man;
import net.molchat.android.core.Setting;
import net.molchat.android.media.Pic;
import net.molchat.android.media.Resource;
import net.molchat.android.mess.MessCont;
import net.molchat.android.mess.Message;
import net.molchat.android.mess.StatOne;
import net.molchat.android.scrn.theme.ContCol;
import net.molchat.android.scrn.theme.ThemeMan;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.Region;
import android.util.Log;
import android.view.KeyEvent;


//FIXME Commented out class


/**
 * Main screen for every type of contact
 * 
 * 
 * 
 * @author Valentyn Markovych, Lsynnc at gmail.com Created: 14.10.2012 0:58:01
 * 
 */
public class WinCont extends WinGraph {


//==================================================================== Constants


//======================================================================= Fields

//-------------------- Screen
protected int dispWold; // Old display width
protected int dispHold; // Old disolay height


//------------------- Заголовок
//Общий фон
protected int titBgX; // Координата X cтроки заголовка
protected int titBgY; // Координата Y cтроки заголовка
protected int titBgW; // Ширина cтроки заголовка
protected int titBgH; // Высота cтроки заголовка

//Текст
protected int titTextX; // Координата X заголовка
protected int titTextY; // Координата Y заголовка
protected int titTextW; // Ширина заголовка
protected int titTextH; // Высота заголовка

//Значок новых сообщений
protected int newX; // Координата X поля новых сообщений
protected int newY; // Координата Y поля новых сообщений
protected int newW; // Ширина поля новых сообщений
protected int newH; // Высота поля новых сообщений


//------------------- Строка статуса
//Общий фон
protected int statBgX; // Координата X cтроки статуса
protected int statBgY; // Координата Y cтроки статуса
protected int statBgW; // Ширина cтроки статуса
protected int statBgH; // Высота cтроки статуса
//Текст
protected int statTextX; // Координата X текста cтроки статуса
protected int statTextY; // Координата Y текста cтроки статуса
protected int statTextW; // Ширина текста статуса
protected int statTextH; // Высота текста статуса
//Поле часов
protected int clkX; // Координата X поля часов
protected int clkY; // Координата Y поля часов
protected int clkW; // Ширина поля часов
protected int clkH; // Высота поля часов

//------------------- Окно сообщений
protected int messX; // Координата X окна сообщений
protected int messY; // Координата Y окна сообщений
protected int messW; // Ширина окна сообщений
protected int messH; // Высота окна сообщений
// Текст сообщений
protected int textX; // Координата X окна текста сообщений
protected int textY; // Координата Y окна текста сообщений
protected int textW; // Ширина окна текста сообщений
protected int textH; // Высота окна текста сообщений
protected int textYMax; // Координата Y окна текста сообщений


// Перерисовка
protected Bitmap bg; // Картинка фона
protected int smlDivider = Setting.smlDivider;
protected int clkDivider;
protected ContCol col; // Цветовая схема


// Отображаемый контакт
private ContGraph cont; // Текущий контакт, отображаемый экраном


////Команды
//public boolean[] coms = new boolean[ScrMan.COM_TOT];
//
//
////====================================================================== Methods
//
////======================================================================== close
//@Override
//public void close(int from) {
//
//}
//
//
////====================================================================== command
//@Override
//public void command(Command command) {
//
//}


//===================================================================== drawMess
protected void drawMess() {

	drawMessBg();
	drawMessText();
}


//====================================================================== updSize
@Override
public void updSize() {

	super.updSize();

	// Заголовок
	titBgX = Draw.fact;
	titBgY = Draw.fact;
	titBgW = Draw.dispW - Draw.fact2;
	titBgH = Draw.fontTitH + Draw.fact4;

	// Значок наличия новых сообщений
	newH = titBgH >> 1;
	newW = newH + (newH >> 1);
	newX = titBgX + titBgW - Draw.fact - newW;
	newY = (titBgY + (titBgH >> 1)) - (newH >> 1);

	// Текст заголовка
	titTextX = titBgX + Draw.fact;
	titTextY = titBgY + Draw.fact;
	titTextW = titBgW - newW - Draw.fact3;
	titTextH = Draw.fontTitH + Draw.fact;

	// Фон статуса
	statBgX = Draw.fact;
	statBgH = Draw.fontStatH + Draw.fact4;
	statBgY = Draw.dispH - statBgH - Draw.fact;
	statBgW = Draw.dispW - Draw.fact2;

	// Часы
	clkW = Draw.timeStatW + Draw.fact;
	clkH = Draw.fontStatH + Draw.fact;
	clkX = statBgX + statBgW - clkW;
	clkY = statBgY + Draw.fact2; /**/

	// Текст статуса
	statTextX = statBgX + Draw.fact2;
	statTextY = statBgY + Draw.fact2;
	statTextW = statBgW - clkW - Draw.fact5;
	statTextH = Draw.fontStatH; /**/

	// Окно сообщений
	messX = Draw.fact;
	messY = titBgY + titBgH + Draw.fact;
	messW = Draw.dispW - Draw.fact2;
	messH = statBgY - messY - Draw.fact;

	// Текст сообщений
	textX = messX + Draw.fact;
	textY = messY;
	textW = messW - Draw.fact2;
	textH = messH - Draw.fact;
	textYMax = textY + textH;
}


//========================================================================= tick 
@Override
public boolean tick() {


	boolean fFlush = super.tick();

	if (--this.smlDivider <= 0) {
		this.smlDivider = Setting.smlDivider;

		// FIXME commented out block
		//		fFlush |= Man.picAni.drawAll();
	}


	if (--this.clkDivider <= 0) {
		this.clkDivider = Setting.clkDivider;
		synchronized (Man.main) {
			drawClk();
		}
		fFlush = true;
	}

	return fFlush;
}


////===================================================================== keyState
//@Override
//public boolean keyState(int state) {
//
//	boolean fFlush = false;
//
//	if ((state & GameCanvas.UP_PRESSED) != 0) {
//		synchronized (Man.main) {
//			cont.selUp();
//			drawMess();
//		}
//		fFlush = true;
//	} else if ((state & GameCanvas.DOWN_PRESSED) != 0) {
//		synchronized (Man.main) {
//			cont.selDown();
//			drawMess();
//		}
//		fFlush = true;
//	} else if ((state & GameCanvas.LEFT_PRESSED) != 0) {
//		Man.scrMan.showPrevCont();
//	} else if ((state & GameCanvas.RIGHT_PRESSED) != 0) {
//		Man.scrMan.showNextCont();
//	}
//
//
//	return fFlush;
//
//}
//
//
////====================================================================== fOnline
//@Override
//public void fOnline(boolean fOnline) {
//
//}


//====================================================================== prepare
@Override
public void prepare(Win oldWin) {

	synchronized (Man.main) {
		if ((dispWold != Draw.dispW) || (dispHold != Draw.dispH)) { // Размер экрана изменился
			updSize();
			makeAllBg();
		}

		drawBg();

		// FIXME commented out block

		drawTitText();
		drawNew();

		//		drawStatText();
		//		drawClkText();
		cont.setSize(textW, textH);
		drawMessText();
	}

}


//======================================================================= inText
@Override
public boolean inText(int contType, int contNum, Message message) {

	int thisContType;

	if (this instanceof One) {
		thisContType = Cont.ONE;
	} else {
		thisContType = Cont.ROOM;
	}

	synchronized (Man.main) {
		if (Man.contMan.isSel(thisContType, contNum)) {
			drawMess();
		} else {
			drawNew();
		}
	}

	return true;
}


//======================================================================= inText
//@Override
//public boolean inText(int contType, int contNum, Message message) {
//
//	int thisContType;
//
//	if (this instanceof One) {
//		thisContType = Cont.ONE;
//	} else {
//		thisContType = Cont.ROOM;
//	}
//
//	synchronized (Man.main) {
//		if (Man.contMan.isSel(thisContType, contNum)) {
//			drawMess();
//		} else {
//			drawNew();
//		}
//	}
//
//	return true;
//}


//======================================================================= inText
protected void drawMessText() {

	//	Log.v("Room.drawMessText", "Рисую текст сообщений");

	int blkType; // Тип отрисовываемого блока
	int bP; // Указатель на начало текста в блоке
	int eP; // Указатель на конец текста в блоке
	boolean fSel; // Отрисовывается выделенное сообщение
	int parseP; // Указатель на символ строки парсинга, который необходимо читать
	int rowH; // Высота строки
	int rowEnd; // Первый символ следующей строки
	int rowLen; // Длина строки в байтах
	int scrX; // Позиция X отрисовки на экране
	String time; // Время в сообщении
	int width; // Ширина блока в точках
	MessCont mess = null; // Отрисовываемое сообщение


	try {
		// int messNum = 0; // Номер отрисовываемого сообщения
		mess = (MessCont) cont.getFirst(); // Первое отрисовываемое сообщение
		int scrY = textY - cont.getDisplace(); // Позиция Y отрисовки на экране
		// Log.v("Room.drawMessText", "displace=" + net.molchat.android.cont.getDisplace());

		textYMax = textY + textH;

		Draw.g.clipRect(textX, textY, textX + textW, textY + textH + 1,
				Region.Op.REPLACE);

		// FIXME commented out block
		//		Man.picAni.reset(col.messBgSel, textX, textY, textW, textH + 1, bg);

		Paint pOther = new Paint();
		//		Draw.g.setFont(Draw.fontMess);

		// Цикл отрисовки сообщений
		while ((mess != null) && scrY < textYMax) {

			parseP = 0; // Указатель на символ строки парсинга, который необходимо читать
			//			String text = mess.text;
			//			Log.v("Room.drawMessText", "Рисую: " + net.molchat.android.mess);

			fSel = cont.isSel();
			if (fSel) { // Отрисовываем выделенное
				Draw.g.clipRect(messX, messY, messX + messW, messY + messH + 1,
						Region.Op.REPLACE);

				pOther.setColor(col.messBgSel);
				Draw.g.drawRect(messX, scrY + 1, messX + messW, scrY + mess.hTot,
						pOther);

				// Линии
				pOther.setColor(col.lineSel);
				Draw.g.drawLine(messX, scrY, messX + messW, scrY, pOther);
				Draw.g.drawLine(messX, scrY + mess.hTot, messX + messW, scrY
						+ mess.hTot, pOther);

				Draw.g.clipRect(textX, textY, textX + textW, textY + textH + 1,
						Region.Op.REPLACE);
			}

			do {
				scrX = textX;

				rowLen = mess.res[parseP];
				rowEnd = parseP + rowLen;
				parseP++;
				rowH = mess.res[parseP++];
				scrY += rowH;

				do { // Цикл отрисовки блоков одной строки
					blkType = mess.res[parseP++];
					switch (blkType) {
						case Message.B_TEXT:
							Draw.fontMess.setColor(col.mess[mess.color]);
							bP = mess.res[parseP++];
							eP = mess.res[parseP++];
							width = mess.res[parseP++];
							//							Draw.g.drawText(mess.text, bP, eP + 1, scrX, scrY
							//									+ Draw.fontMessH, Draw.fontMess);
							Draw.g.drawText(mess.text, bP, eP + 1, scrX, scrY, Draw.fontMess);
							scrX += width;
							break;

						case Message.B_SMILE:
							int smlNum = mess.res[parseP++];
							Pic sml = (Pic) Man.resMan.getRes(Long.valueOf(smlNum));
							int smlY = scrY - sml.h;
							if (sml.type == Resource.TYPE_PIC_ANI) { // Смайл анимирован
								if ((scrY < Draw.dispH) && (smlY > 0)) { // Умещается на экране
									// FIXME comm
									//									Man.picAni.addPic(sml, scrX, smlY, fSel);
								}
							}
							sml.draw(Draw.g, scrX, smlY);
							scrX += sml.w;
							break;

						case Message.B_TIME:
							time = mess.getTimeString();
							Draw.fontClk.setColor(col.messClk[mess.color]);
							//							Draw.g.drawText(time, scrX, scrY + Draw.fontClkH, Draw.fontClk);
							Draw.g.drawText(time, scrX, scrY, Draw.fontClk);
							scrX += Draw.timeMessW + Draw.timeMessOff;
							break;

						case Message.B_NICKS:
							Draw.fontMess.setColor(col.messNick);
							bP = mess.res[parseP++];
							eP = mess.res[parseP++];
							width = mess.res[parseP++];
							//							Draw.g.drawText(mess.nicks, bP, eP + 1, scrX, scrY
							//									+ Draw.fontMessH, Draw.fontMess);
							Draw.g
									.drawText(mess.nicks, bP, eP + 1, scrX, scrY, Draw.fontMess);
							scrX += width;
							break;

						case Message.B_TAB:
							break;

						default:
							Log.e("Room.drawMessText", "Неизвестный тип блока (" + blkType
									+ ")");
					}
				} while (parseP < rowEnd);

				parseP++;
			} while ((scrY < textYMax) && (parseP < mess.res.length));

			mess = (MessCont) cont.getNext(); // Конец цикла отрисовки блоков одного сообщения
		}

		//		Log.v("Room.drawMessText", "Конец отрисовки текста. Всего " + tempMessNum);

		//	}
	} catch (Exception e) {
		Log.e("WinCont.drawMessText", "Message drawing error: " + mess, e);
	}
	//	Log.v("Room.drawMessText", "Конец отрисовки текста");
}


/**
 * onKeyDown processing method.
 * 
 */
@Override
public boolean keyDown(int keyCode, KeyEvent event) {


	boolean fFlush = false;

	switch (keyCode) {
		case KeyEvent.KEYCODE_DPAD_UP:
			synchronized (Man.main) {
				cont.selUp();
				drawMess();
			}
			fFlush = true;
			break;

		case KeyEvent.KEYCODE_DPAD_DOWN:
			synchronized (Man.main) {
				cont.selDown();
				drawMess();
			}
			fFlush = true;
			break;

		case KeyEvent.KEYCODE_DPAD_LEFT:
			Man.scrMan.showPrevCont();
			break;

		case KeyEvent.KEYCODE_DPAD_RIGHT:
			Man.scrMan.showNextCont();
			break;

	//		case Canvas.FIRE:
	//			Man.scrMan.sendMess();
	//			break;
	//
	//		case Canvas.GAME_A:
	//			Man.scrMan.showContList();
	//			break;
	//
	//		case Canvas.GAME_B:
	//			Man.scrMan.outRoomWho();
	//			break;
	//
	//		case Canvas.GAME_C:
	//			break;
	//
	//		case Canvas.GAME_D:
	//			Man.scrMan.sendMess();
	//			break;
	}

	return fFlush;

}


//====================================================================== doDrag
@Override
public boolean doDrag(int offX, int offY) {

	if (offY != 0) {
		synchronized (Man.main) {
			this.cont.move(-offY * Setting.touchSpeedC);
			this.drawMess();
		}
		return true;
	} else {
		return false;
	}
}


////====================================================================== dragged
//@Override
//public boolean doDrag(int offX, int offY) {
//
//	if (offY != 0) {
//		synchronized (Man.main) {
//			this.cont.move(-offY * Setting.touchSpeedC);
//			this.drawMess();
//		}
//		return true;
//	} else {
//		return false;
//	}
//}


//====================================================================== setCont
protected void setCont(ContGraph cont, int contNum) {

	this.cont = cont;
	int themeType;
	if (this instanceof One) {
		themeType = Cont.ONE;
	} else {
		themeType = Cont.ROOM;
	}
	col = ThemeMan.getCol(themeType, contNum);
}


//==================================================================== makeAllBg
protected void makeAllBg() {

	try {
		if ((bg == null) || (bg.getWidth() != Draw.dispW)
				|| (bg.getHeight() != Draw.dispH)) { // Картинка фона еще не создана

			Log.v("WinCont.makeAllBg", "Making backgroumg image");

			bg = Bitmap.createBitmap(Draw.dispW, Draw.dispH, Bitmap.Config.ARGB_8888);
			Canvas g = new Canvas(bg);

			makeScrBg(g);
			makeTitBg(g);
			makeStatBg(g);
		}

	} catch (Exception e) {
		Log.e("One.makeAllBg", "Не могу создать картинку фона", e);
	}
}


//=================================================================== makeStatBg
protected void makeStatBg(Canvas g) {

	Draw.rectG(g, statBgX, statBgY + Draw.fact, statBgW, (statBgH - Draw.fact2)
			- ((statBgH - Draw.fact2) >> 2), col.statBg1, col.statBg2);
	Draw.rectG(g, statBgX, statBgY + Draw.fact + (statBgH - Draw.fact2)
			- ((statBgH - Draw.fact2) >> 2), statBgW, (statBgH - Draw.fact2) >> 2,
			col.statBg2, col.statBg1);

	Paint p = new Paint();
	p.setColor(col.line);
	g.drawLine(statBgX, statBgY, statBgX + statBgW, statBgY, p);
	g.drawLine(statBgX, statBgY + statBgH, statBgX + statBgW, statBgY + statBgH,
			p);
}


//==================================================================== makeTitBg
protected void makeTitBg(Canvas g) {

	Draw.rectG(g, titBgX, titBgY + Draw.fact, titBgW, (titBgH - Draw.fact2)
			- ((titBgH - Draw.fact2) >> 2), col.titBg2, col.titBg1);
	Draw.rectG(g, titBgX, titBgY + Draw.fact + (titBgH - Draw.fact2)
			- ((titBgH - Draw.fact2) >> 2), titBgW, (titBgH - Draw.fact2) >> 2,
			col.titBg1, col.titBg2);

	Paint p = new Paint();
	p.setColor(col.line);
	g.drawLine(titBgX, titBgY, titBgX + titBgW, titBgY, p);
	g.drawLine(titBgX, titBgY + titBgH, titBgX + titBgW, titBgY + titBgH, p);
}


//==================================================================== makeScrBg
protected void makeScrBg(Canvas g) {

	Draw.rectG(g, 0, 0, Draw.dispW, Draw.dispH >> 2, col.scrBg1, col.scrBg2);
	Draw.rectG(g, 0, Draw.dispH >> 2, Draw.dispW, Draw.dispH - (Draw.dispH >> 2),
			col.scrBg2, col.scrBg1);
}


//==================================================================== isGraphic
@Override
public boolean isGraphic() {

	return true;
}


////========================================= Вернуть перечень необходимых команд
//@Override
//public boolean[] getComs() {
//
//	return coms;
//};


//=================================================================== drawMessBg
protected void drawMessBg() {

	Log.v("Room.drawMessBg", "Рисую фон сообщений");
	Draw.g
			.clipRect(messX, messY, messX + messW, messH + messY, Region.Op.REPLACE);
	Rect toDraw = new Rect(messX, messY, messX + messW, messY + messH);
	Draw.g.drawBitmap(bg, toDraw, toDraw, null);
}


//====================================================================== drawNew
/**
 * Draw a symbol of new messages.
 * 
 */
protected void drawNew() {

	Draw.g.clipRect(newX, newY, newX + newW, newY + newH, Region.Op.REPLACE);
	//	Draw.g.clipRect(0, 0, Draw.dispW, Draw.dispH, Region.Op.REPLACE);

	Rect toDraw = new Rect(newX, newY, newX + newW, newY + newH);
	Draw.g.drawBitmap(bg, toDraw, toDraw, null);

	if (Man.contMan.getNewState() > 0) { // Есть новые

		Paint p = new Paint();
		p.setColor(Draw.makeColShad(col.titBg1, col.shad));

		// Shadows
		Rect shad = new Rect(newX + Draw.fact, newY + newH - Draw.fact,
				newX + newW, newY + newH);
		Draw.g.drawRect(shad, p);
		shad.set(newX + newW - Draw.fact, newY + Draw.fact, newX + newW, newY
				+ newH);
		Draw.g.drawRect(shad, p);

		// Box
		Draw.rectG(Draw.g, newX + 1, newY + 1, newW - Draw.fact - 2, newH
				- Draw.fact - 2, col.newBg1, col.newBg2);

		// Bounding lines
		p.setColor(col.lineNew);
		Draw.g.drawLine(newX, newY, newX + newW - Draw.fact - 1, newY, p);
		Draw.g.drawLine(newX, newY + newH - Draw.fact - 1, newX + newW - Draw.fact
				- 1, newY + newH - Draw.fact - 1, p);
		Draw.g.drawLine(newX, newY, newX, newY + newH - Draw.fact - 1, p);
		Draw.g.drawLine(newX + newW - Draw.fact - 1, newY, newX + newW - Draw.fact
				- 1, newY + newH - Draw.fact, p);

		// Crossed lines
		p.setAntiAlias(true);
		Draw.g.drawLine(newX + 1, newY + 1, newX + newW - Draw.fact - 1, newY
				+ newH - Draw.fact - 1, p);
		Draw.g.drawLine(newX + newW - Draw.fact - 1, newY + 1, newX + 1, newY
				+ newH - Draw.fact - 1, p);
	}
}


//============================================================= Изменился статус
@Override
public boolean chStat(String statText) {

	synchronized (Man.main) {
		this.drawStat();
		this.drawTit();
	}
	return true;
}


//====================================================================== drawClk
protected void drawClk() {


	Draw.g.clipRect(clkX, clkY, clkX + clkW, clkY + clkH, Region.Op.REPLACE);

	Rect toDraw = new Rect(clkX, clkY, clkX + clkW, clkY + clkH);
	Draw.g.drawBitmap(bg, toDraw, toDraw, null);
	drawClkText();
}


//Только текст
protected void drawClkText() {

	Draw.g.clipRect(clkX, clkY, clkX + clkW, clkY + clkH, Region.Op.REPLACE);
	Draw.drawShadText(net.molchat.android.core.Clock.getTime(), Draw.fontClk,
			clkX, clkY, col.clk, Draw.makeColShad(col.statBg2, col.shad));
}


////===================================================================== drawBtns
//@Override
//public void drawBtns() {
//
//	if (this.msgBtns != null) {
//		this.fBtnShow = true;
//
//		int addW;
//		int addH;
//
//		// Calculate button box and offsets
//		synchronized (Man.main) {
//			switch (Setting.btnLayout) {
//				case Setting.BTN_LAY_HOR:
//					boxW = this.msgBtns.length * (Draw.btnW + Draw.btnGap) - Draw.btnGap;
//					boxH = Draw.btnH;
//					// Near pressing point
//					//					boxX = this.lastPX - (boxW >> 1);
//					//					boxY = this.lastPY - (Draw.btnH >> 1) - Draw.btnH;
//
//					addW = Draw.btnW + Draw.btnGap;
//					addH = 0;
//					break;
//				default: // Vertical layout
//					boxW = Draw.btnW;
//					boxH = this.msgBtns.length * (Draw.btnH + Draw.btnGap) - Draw.btnGap;
//					// Near pressing point
//					//					boxX = this.lastPX + (Draw.btnW >> 1);
//					//					boxY = this.lastPY - (boxH >> 1);
//
//					addW = 0;
//					addH = Draw.btnH + Draw.btnGap;
//			}
//
//			// Top right corner
//			boxX = textX + textW - Draw.fact - boxW;
//			boxY = textY + Draw.fact;
//
//			// Disable smiles
//			Man.picAni.disArea(boxX, boxY, boxW, boxH);
//
//
//			// Draw buttons
//			for (int q = this.msgBtns.length - 1; q >= 0; --q) {
//				msgBtns[q].x = boxX + addW * q;
//				msgBtns[q].y = boxY + addH * q;
//				msgBtns[q].setState(Button.ST_NORMAL);
//				msgBtns[q].draw(Draw.g);
//			}
//		}
//	} else {
//		this.fBtnShow = false;
//	}
//
//
//}


//======================================================================= drawBg
/**
 * Draw all background.
 * 
 */
protected void drawBg() {

	Draw.g.clipRect(0, 0, Draw.dispW, Draw.dispH, Region.Op.REPLACE);
	Draw.g.drawBitmap(bg, 0, 0, null);
}


//====================================================================== drawTit
protected void drawTit() {

	Log.v("Room.drawTitle", "Рисую заголовок");
	Draw.g.clipRect(titTextX, titTextY, titTextX + titTextW, titTextY + titTextH,
			Region.Op.REPLACE);
	Rect toDraw = new Rect(titTextX, titTextY, titTextX + titTextW, titTextY
			+ titTextH);
	Draw.g.drawBitmap(bg, toDraw, toDraw, null);
	drawTitText();
}


protected void drawTitText() {

	Draw.g.clipRect(titTextX, titTextY, titTextX + titTextW, titTextY + titTextH);
	int color;
	if (cont.statNum >= StatOne.ONLINE) {
		color = col.tit_online;
	} else {
		color = col.tit_offline;
	}
	Draw.drawShadText(cont.getTitText(), Draw.fontTit, titTextX, titTextY, color,
			Draw.makeColShad(col.titBg1, col.shad));
}


//===================================================================== drawStat
protected void drawStat() {

	Draw.g.clipRect(statTextX, statTextY, statTextX + statTextW, statTextY
			+ statTextH, Region.Op.REPLACE);

	Rect toDraw = new Rect(statTextX, statTextY, statTextX + statTextW, statTextY
			+ statTextH);
	Draw.g.drawBitmap(bg, toDraw, toDraw, null);
	drawStatText();
}


// Только текст
protected void drawStatText() {

	Draw.g.clipRect(statTextX, statTextY, statTextX + statTextW, statTextY
			+ statTextH, Region.Op.REPLACE);
	Draw.drawShadText(Man.ioMan.status, Draw.fontStat, statTextX, statTextY,
			col.stat, Draw.makeColShad(col.statBg2, col.shad));
}


@Override
protected void doSelect(int x, int y) {


	boolean wasSel = this.cont.select(x, y - textY);
	synchronized (Man.main) {
		this.drawMess();
	}

	if (wasSel) {
		Man.scrMan.sendMess();
	}
}

////===================================================================== doSelect
//@Override
//protected void doSelect(int x, int y) {
//
//boolean wasSel = this.cont.select(x, y - textY);
//synchronized (Man.main) {
//this.drawMess();
//}
//
//if (wasSel) {
//Man.scrMan.sendMess();
//}
//}


}
